COMMENT ⊗   VALID 00002 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	servo[f83,jmc]		logical servomechanisms in AI
C00011 ENDMK
C⊗;
servo[f83,jmc]		logical servomechanisms in AI

"Every day in every way I get better and better"
The exact quote is "Every day in every way I am getting better and better".
It is attributed to a self-proclaimed French psychoterapist named Emil
Coue(withe accent on the e) who lived 1857-1926.  Information found in
Home book of Qutations by Stevenson, page 872.

	Much of what we want to tell a reasoning program (RP) about
how to achieve its goals can be expressed by telling it how
to compare two situations and decide which is better.  Much of
what is written for people about how to accomplish a task
can be interpreted in this way.  This note contains new and
revived proposals for integrating this idea into a reasoning
program.  We emphasize the blocks world.

	(Huberman 196x) is a Stanford PhD thesis that applies
this idea to three chess endgames ((R K) vs. K), ((B B K) vs. K),
and ((B N K) vs. K).  The idea was to interpret the advice
about how to checkmate given in (Capablanca 193x) as
a statement about what constitutes an improvement in the
position.  This amounts to a comparison predicate
better(p1,p2) that sometimes asserts that one position is
better than another.  The ordering of positions given by  better
is not total, but it has the property that a sequence of better
and better positions must terminate in checkmate.  The program
is a breadth first search for a strategy that improves the
position.

	The program used to compute  better(p1,p2)  is a compromise
between the time required to compute  better(p1,p2)  and the amount
of lookahead required to see how to force an improvement in position.
One extreme is that  better(p1,p2)  is true only if  p1  is a
checkmate.  better  is then a simple program, but lookahead to the
end of the game is required.  The other extreme is that  better(p1,p2)
is true exactly when there are fewer moves to checkmate in  p1  than
in  p2.  Then the lookahead is exactly one move, but  better(p1,p2)  is
difficult to compute.

	In the case of rook and king against king, an appropriate
compromise  better(p1,p2)  can be described as follows.
The positions are divided into numbered classes and a class with
higher number is considered better.  Class 0 are general positions,
i.e. positions that are not in the other classes.  Class 1 consists
of positions in which the enemy king is confined to a rectangle by
the rook and our king is outside the rectangle.  Within class 1
positions, it is better if our king is closer to our rook.  If the
king is adjacent to the rook, it is a class 2 position.  Within
class 2 positions, it is better if the enemy king is confined to
a smaller number of rows.  A class 3 position is one in which the
enemy king is confined to an edge of the board.  Within class 3
positions,  p1  is better than  p2  if the position is closer
to our having the opposition which is class 4.  Within class 4,
it's better if the enemy king is closer to the end of the edge
away from the rook.  Class 5 is checkmate.  This is approximately
the predicate used in Huberman's thesis, but I haven't checked
recently.

	When this predicate is used, at most three plies of
lookahead are required to improve the position.  The other
checkmates are somewhat more complex, but the idea is the same.
An additional predicate  worse(p1,p2)  or  bad(p)  can be used
with the proviso that the program never searches beyond a bad
position or worse position in the hope that more lookahead
will provide an improvement.  This takes care of loosing a piece
and other disasters.  It also reduces search to put a plausibility
ordering on moves and to use the alpha-beta heuristic.

	Moreover, it seemed subjectively that the  better  predicate
was indeed appropriate for expressing most of the advice in Capablanca's
book.

	So much for the 1960s.  The idea was subsequently used
by Donald Michie and Ivan Bratko.  It would be a worthwhile project
to redo the Huberman problems in modern Lisp for the Lisp machine
and try to make the mechanisms more modular and understandable.

	Our present idea is to make  better  predicates the basis
of programs that solve problems by logical reasoning.
Suppose, for example, that we have a blocks world axiomatization
using the "situation calculus" of (McCarthy and Hayes 1969)
modified to handle the frame problem using circumscription (McCarthy
1980 and 1983).  We now supplement these axioms with others
describing when one situation is better than another.  The
program then looks ahead to find a sequence of moves that
leads to a better position.  If  better(s1,s2)  is properly
defined, this is far less work than computing a strategy that
achieves the ultimate goal.  Moreover, in non-competitive
problems such as the blocks world, the whole problem is
much simpler than for chess.

	The analogy with analog servomechanisms is suggestive.
There we often have structures in which outer servo loops have
inner loops.  This will also be wanted in logical servomechanisms.
For example, demons can often be regarded as logical servomechanisms
that maintain conditions and avoid certain disasters.

	We can compare the use of  better  with the use of production rules.
Production rules are more like a reflex, and  better  is more like
thought.  The production rules avoid search except for the applicable
rule, but are less modular.  However, the proof of the pudding will
be in the eating.